home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Edition 10 / FreelogHS10.iso / Buzz / Buzz_Advanced_Pack.exe / {app} / Dev / Noise / Noise.cpp next >
C/C++ Source or Header  |  2001-08-27  |  7KB  |  399 lines
  1.  
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <math.h>
  6. #include <float.h>
  7. #include "../../MachineInterface.h"
  8. #include "../../dsplib/dsplib.h"
  9.  
  10. #pragma optimize ("a", on)
  11.  
  12. #define MAX_TRACKS                8
  13.  
  14. #define EGS_ATTACK                0
  15. #define EGS_SUSTAIN                1 
  16. #define EGS_RELEASE                2
  17. #define EGS_NONE                3
  18.  
  19. #define MIN_AMP                    (0.0001 * (32768.0 / 0x7fffffff))
  20.  
  21. double const oolog2 = 1.0 / log(2);
  22.  
  23. CMachineParameter const paraAttack = 
  24. { 
  25.     pt_word,                                        // type
  26.     "Attack",
  27.     "Attack time in ms",                            // description
  28.     1,                                                // MinValue    
  29.     0xffff,                                            // MaxValue
  30.     0,                                                // NoValue
  31.     MPF_STATE,                                        // Flags
  32.     16
  33. };
  34.  
  35. CMachineParameter const paraSustain = 
  36. {  
  37.     pt_word,                                        // type
  38.     "Sustain",
  39.     "Sustain time in ms",                            // description
  40.     1,                                                // MinValue    
  41.     0xffff,                                            // MaxValue
  42.     0,                                                // NoValue
  43.     MPF_STATE,                                        // Flags
  44.     16
  45. };
  46.  
  47. CMachineParameter const paraRelease = 
  48. { 
  49.     pt_word,                                        // type
  50.     "Release",
  51.     "Release time in ms",                            // description
  52.     1,                                                // MinValue    
  53.     0xffff,                                            // MaxValue
  54.     0,                                                // NoValue
  55.     MPF_STATE,                                        // Flags
  56.     512
  57. };
  58.  
  59. CMachineParameter const paraColor = 
  60. { 
  61.     pt_word,                                        // type
  62.     "Color",
  63.     "Noise color (0=black, 1000=white)",            // description
  64.     0,                                                // MinValue    
  65.     0x1000,                                            // MaxValue
  66.     0xffff,                                            // NoValue
  67.     MPF_STATE,                                        // Flags
  68.     0x1000
  69. };
  70.  
  71. CMachineParameter const paraVolume = 
  72. { 
  73.     pt_byte,                                        // type
  74.     "Volume",
  75.     "Volume [sustain level] (0=0%, 80=100%, FE=~200%)",    // description
  76.     0,                                                // MinValue    
  77.     0xfe,                                              // MaxValue
  78.     0xff,                                            // NoValue
  79.     MPF_STATE,                                        // Flags
  80.     0x80
  81. };
  82.  
  83. CMachineParameter const paraTrigger = 
  84. { 
  85.     pt_switch,                                        // type
  86.     "Trigger",
  87.     "Trigger (1=on, 0=off)",                        // description
  88.     -1,                                             // MinValue    
  89.     -1,                                                  // MaxValue
  90.     SWITCH_NO,                                        // NoValue
  91.     0,                                                // Flags
  92.     0
  93. };
  94.  
  95.  
  96. CMachineParameter const *pParameters[] = { 
  97.     // track
  98.     ¶Attack,
  99.     ¶Sustain,
  100.     ¶Release,
  101.     ¶Color,
  102.     ¶Volume,
  103.     ¶Trigger
  104. };
  105.  
  106. #pragma pack(1)
  107.  
  108. class tvals
  109. {
  110. public:
  111.     word attack;
  112.     word sustain;
  113.     word release;
  114.     word color;
  115.     byte volume;
  116.     byte trigger;
  117.  
  118. };
  119.  
  120. #pragma pack()
  121.  
  122. CMachineInfo const MacInfo = 
  123. {
  124.     MT_GENERATOR,                            // type
  125.     MI_VERSION,
  126.     0,                                        // flags
  127.     1,                                        // min tracks
  128.     MAX_TRACKS,                                // max tracks
  129.     0,                                        // numGlobalParameters
  130.     6,                                        // numTrackParameters
  131.     pParameters,
  132.     0, 
  133.     NULL,
  134. #ifdef _DEBUG
  135.     "Jeskola Noise Generator (Debug build)",            // name
  136. #else
  137.     "Jeskola Noise Generator",
  138. #endif
  139.     "Noise",                                // short name
  140.     "Oskari Tammelin",                         // author
  141.     NULL
  142. };
  143.  
  144. class mi;
  145.  
  146. class mi;
  147.  
  148. class CTrack
  149. {
  150. public:
  151.     void Tick(tvals const &tv);
  152.     void Stop();
  153.     void Reset();
  154.     void Generate(float *psamples, int numsamples);
  155.     void Noise(float *psamples, int numsamples);
  156.  
  157.     int MSToSamples(double const ms);
  158.  
  159. public:
  160.     double Amp;
  161.     double AmpStep;
  162.     double S1;
  163.     double S2;
  164.  
  165.     float Volume;
  166.     int Pos;
  167.     int Step;
  168.     int RandStat;
  169.     
  170.     int EGStage;
  171.     int EGCount;
  172.     int Attack;
  173.     int Sustain;
  174.     int Release;
  175.  
  176.     mi *pmi;
  177. };
  178.  
  179. class mi : public CMachineInterface
  180. {
  181. public:
  182.     mi();
  183.     virtual ~mi();
  184.  
  185.     virtual void Init(CMachineDataInput * const pi);
  186.     virtual void Tick();
  187.     virtual bool Work(float *psamples, int numsamples, int const mode);
  188.     virtual void SetNumTracks(int const n) { numTracks = n; }
  189.     virtual void Stop();
  190.  
  191. public:
  192.     int numTracks;
  193.     CTrack Tracks[MAX_TRACKS];
  194.  
  195.     tvals tval[MAX_TRACKS];
  196.  
  197. };
  198.  
  199. DLL_EXPORTS
  200.  
  201. mi::mi()
  202. {
  203.     GlobalVals = NULL;
  204.     TrackVals = tval;
  205.     AttrVals = NULL;
  206. }
  207.  
  208. mi::~mi()
  209. {
  210.  
  211. }
  212.  
  213. inline int CTrack::MSToSamples(double const ms)
  214. {
  215.     return (int)(pmi->pMasterInfo->SamplesPerSec * ms * (1.0 / 1000.0));
  216. }
  217.  
  218. inline double CalcStep(double from, double to, int time)
  219. {
  220.     assert(from > 0);
  221.     assert(to > 0);
  222.     assert(time > 0);
  223.     return pow(to / from, 1.0 / time);
  224. }
  225.  
  226. void CTrack::Reset()
  227. {
  228.     EGStage = EGS_NONE;
  229.  
  230.     Attack = MSToSamples(16);
  231.     Sustain = MSToSamples(16);
  232.     Release = MSToSamples(512);
  233.  
  234.     Pos = 0;
  235.     Step = 65536;
  236.     Volume = 1.0;
  237.     S1 = S2 = 0;
  238.     RandStat = 0x16BA2118;
  239. }
  240.  
  241. void mi::Init(CMachineDataInput * const pi)
  242. {
  243.     for (int c = 0; c < MAX_TRACKS; c++)
  244.     {
  245.         Tracks[c].pmi = this;
  246.         Tracks[c].Reset();
  247.     }
  248.  
  249. }
  250.  
  251. void CTrack::Tick(tvals const &tv)
  252. {
  253.     if (tv.attack != paraAttack.NoValue)
  254.         Attack = MSToSamples(tv.attack);
  255.  
  256.     if (tv.sustain != paraSustain.NoValue)
  257.         Sustain = MSToSamples(tv.sustain);
  258.  
  259.     if (tv.release != paraRelease.NoValue)
  260.         Release = MSToSamples(tv.release);
  261.  
  262.     if (tv.color != paraColor.NoValue)
  263.         Step = tv.color * 16;    // 0..4096 -> 0..65536
  264.     
  265.     if (tv.volume != paraVolume.NoValue)
  266.         Volume = (float)(tv.volume * (1.0 / 0x80));
  267.  
  268.     if (tv.trigger != SWITCH_NO)
  269.     {
  270.         if (Volume > 0)
  271.         {
  272.             EGStage = EGS_ATTACK;
  273.             EGCount = Attack;
  274.             Amp = MIN_AMP;
  275.             AmpStep = CalcStep(MIN_AMP, Volume * (32768.0 / 0x7fffffff), Attack);
  276.         }
  277.     }
  278. }
  279.  
  280. void CTrack::Noise(float *psamples, int numsamples)
  281. {
  282.     double amp = Amp;
  283.     double const ampstep = AmpStep;        
  284.     double s1 = S1;
  285.     double s2 = S2;
  286.     int const step = Step;
  287.     int stat = RandStat;
  288.     int pos = Pos;
  289.  
  290.     int c = numsamples;
  291.     do
  292.     {
  293.         *psamples++ = (float)(s1 + (s2 - s1) * (pos * 1.0 / 65536.0));
  294.         amp *= ampstep;
  295.  
  296.         pos += step;
  297.         if (pos & 65536)
  298.         {
  299.             s1 = s2;
  300.             stat = ((stat * 1103515245 + 12345) & 0x7fffffff) - 0x40000000;
  301.             s2 = stat * amp;
  302.  
  303.             pos -= 65536;
  304.         }
  305.  
  306.     } while(--c);
  307.  
  308.     Pos = pos;
  309.     S2 = s2;
  310.     S1 = s1;
  311.     RandStat = stat;
  312.     Amp = amp;
  313. }
  314.  
  315. void CTrack::Generate(float *psamples, int numsamples)
  316. {
  317.     do
  318.     {
  319.         int const c = __min(EGCount, numsamples);
  320.         assert(c > 0);
  321.  
  322.         if (EGStage != EGS_NONE)
  323.             Noise(psamples, c);
  324.         else
  325.             memset(psamples, 0, c * sizeof(float));
  326.         
  327.         numsamples -= c;
  328.         psamples += c;
  329.         EGCount -= c;
  330.  
  331.         if (!EGCount)
  332.         {
  333.             switch(++EGStage)
  334.             {
  335.             case EGS_SUSTAIN:
  336.                 EGCount = Sustain;
  337.                 AmpStep = 1.0;
  338.                 break;
  339.             case EGS_RELEASE:
  340.                 EGCount = Release;
  341.                 AmpStep = CalcStep(Amp, MIN_AMP, Release);
  342.                 break;
  343.             case EGS_NONE:
  344.                 EGCount = 0x7fffffff;
  345.                 break;
  346.             }
  347.         }
  348.  
  349.         
  350.  
  351.     } while(numsamples > 0);
  352. }
  353.  
  354. void mi::Tick()
  355. {
  356.     for (int c = 0; c < numTracks; c++)
  357.         Tracks[c].Tick(tval[c]);
  358.  
  359. }
  360.  
  361. bool mi::Work(float *psamples, int numsamples, int const)
  362. {
  363.     bool gotsomething = false;
  364.  
  365.     for (int c = 0; c < numTracks; c++)
  366.     {
  367.         if (Tracks[c].EGStage != EGS_NONE)
  368.         {
  369.             if (!gotsomething)
  370.             {
  371.                 Tracks[c].Generate(psamples, numsamples);
  372.                 gotsomething = true;
  373.             }
  374.             else
  375.             {
  376.                 float *paux = pCB->GetAuxBuffer();
  377.                 Tracks[c].Generate(paux, numsamples);
  378.  
  379.                 DSP_Add(psamples, paux, numsamples);
  380.  
  381.             }
  382.         }
  383.     }
  384.  
  385.     return gotsomething;
  386. }
  387.  
  388. void CTrack::Stop()
  389. {
  390.     EGStage = EGS_NONE;
  391. }
  392.  
  393. void mi::Stop()
  394. {
  395.     for (int c = 0; c < numTracks; c++)
  396.         Tracks[c].Stop();
  397. }
  398.  
  399.